import axios from 'axios'
import qs from 'qs'
import router from '../../router'
import {
  BASE_URL,
  /* SUCCESS, */
  NEED_LOGIN,
  OVERDUE_LOGIN,
  REPEAT_LOGIN
} from '../../config'
import { saveAuthInfo, getAuthInfo } from './cache'
import { debounce } from '../../utils'
import AuthService from '../../service/auth'

// 是否正在刷新的标记
let isRefreshing = false

// 重试队列，每一项将是一个待执行的函数形式
let retryRequests = []

// 消息防抖(警告)
const messageWarning = debounce(window.ELEMENT.Message.warning, 1000, true)

// 消息防抖(错误)
const messageError = debounce(window.ELEMENT.Message.error, 1000, true)

// 设置 axios 默认Url
axios.defaults.baseURL = BASE_URL

// 设置 axios 默认请求类型
axios.defaults.headers.post['Content-Type'] =
  'application/x-www-form-urlencoded'

// 设置 axios 默认超时时间
axios.defaults.timeout = 360000

// 添加请求拦截
axios.interceptors.request.use(
  config => {
    const authInfo = getAuthInfo()

    if (authInfo) {
      // 设置 axios 默认请求头
      config.headers.Authorization = `Bearer ${authInfo.accessToken}`
    }

    if (config.method === 'post') {
      config.data = qs.stringify(config.data)
    }
    return config
  },
  error => {
    // 错误的传参
    return Promise.reject(error)
  }
)

// 添加响应拦截器
axios.interceptors.response.use(
  response => {
    return response
    /*  if (response.data.status === SUCCESS) {
      return response.data
    } else {
      return Promise.reject(response.data.message)
    } */
  },
  error => {
    const config = error.config

    const authInfo = getAuthInfo()

    if (error.response) {
      switch (error.response.status) {
        case 401:
          if (error.response.data.status === NEED_LOGIN) {
            // 跳转登录页面
            router.replace({
              path: '/login'
            })
            messageError(error.response.data)
          }

          if (error.response.data.status === OVERDUE_LOGIN) {
            if (!isRefreshing) {
              isRefreshing = true
              return AuthService.refreshToken(authInfo.refreshToken)
                .then(res => {
                  // 存储 Auth 信息
                  saveAuthInfo(res.data)
                  config.headers.Authorization = `Bearer ${
                    res.data.accessToken
                  }`
                  retryRequests.forEach(item => item(res.data.accessToken))
                  // 重试完清空队列
                  retryRequests = []
                  // 清空baseURL
                  config.baseURL = ''
                  return axios(config)
                })
                .finally(() => {
                  isRefreshing = false
                })
            } else {
              // 正在刷新Token，返回一个未执行Resolve的Promise
              return new Promise(resolve => {
                // 将Resolve放进队列，用一个函数形式来保存，等Token刷新后直接执行
                retryRequests.push(token => {
                  config.baseURL = ''
                  config.headers.Authorization = `Bearer ${token}`
                  resolve(axios(config))
                })
              })
            }
          }

          if (error.response.data.status === REPEAT_LOGIN) {
            // 跳转登录页面
            router.replace({
              path: '/login'
            })
            messageError(error.response.data)
          }
          break
        case 403:
          messageError(error.response.data)
          break
        case 404:
          messageError('当前请求的接口不存在')
          break
        case 429:
          // 请求繁忙
          messageWarning('请求繁忙，请稍后重试')
          break
        default:
          messageError(error.response.data)
      }
    }
    // 返回接口返回的错误信息
    return Promise.reject(error)
  }
)

class Requset {
  /**
   * GET请求封装
   * @param url 请求地址
   * @param data 请求参数
   */
  static get(url, params) {
    const data = {
      params
    }

    return axios.get(url, data)
  }
  /**
   * POST请求封装
   * @param url 请求地址
   * @param data 请求参数
   */
  static post(url, data) {
    return axios.post(url, data)
  }
}

export default Requset
